// import store from "@/store/index.js";
// import router from "@/router/routers.js";
// import onlineApi from "@/api/documents/onlineApi.js";
// import bugIcon from "@/assets/images/bug.png";
// import { Notification } from "element-ui";

import router from '@/router';

var iconArray = [
  {
    suffix: ['xls', 'xlsx', 'xlsb', 'xlsm'],
    icon: 'Excel'
  },
  {
    suffix: ['doc', 'docx'],
    icon: 'Word'
  },
  {
    suffix: ['ppt', 'pptx', 'pps', 'ppsx'],
    icon: 'PPT'
  },
  {
    suffix: ['mp3', 'wav', 'wmv'],
    icon: 'music'
  },
  {
    suffix: ['mp4', 'm2v', 'mkv'],
    icon: 'shipin'
  },
  {
    suffix: ['png', 'jpg', 'jpeg', 'bmp', 'ico'],
    icon: 'tupian'
  },
  {
    suffix: ['gif'],
    icon: 'Gif'
  },
  {
    suffix: ['pdf'],
    icon: 'Pdf'
  },
  {
    suffix: ['txt'],
    icon: 'txt'
  },
  {
    suffix: ['sql'],
    icon: 'shujuku'
  },
  {
    suffix: ['rar', 'zip', 'rar4', '7z'],
    icon: 'yasuobao'
  },
  {
    suffix: ['html'],
    icon: 'chengxu'
  },
  // 自定义表单文档
  {
    suffix: ['richText'],
    icon: 'biaodan3'
  }
];
// 畅写在线编辑===================start
var suffixList = [
  'doc',
  'docm',
  'docx',
  'dot',
  'dotm',
  'dotx',
  'epub',
  'fodt',
  'htm',
  'html',
  'mht',
  'odt',
  'ott',
  'rtf',
  'txt',
  'xps',
  'wps',
  'doc',
  'docm',
  'docx',
  'dot',
  'dotm',
  'dotx',
  'epub',
  'fodt',
  'htm',
  'html',
  'mht',
  'odt',
  'ott',
  'rtf',
  'txt',
  'xps',
  'wps',
  'csv',
  'fods',
  'ods',
  'ots',
  'xls',
  'xlsm',
  'xlsx',
  'xlt',
  'xltm',
  'xltx',
  'et',
  'fodp',
  'odp',
  'otp',
  'pot',
  'potm',
  'potx',
  'pps',
  'ppsm',
  'ppsx',
  'ppt',
  'pptm',
  'pptx',
  'dps'
];

export const suffixLists = suffixList;
// 在线编辑===================end
//冰蓝在线编辑的配置------start
var suffixList_iceBlue = [
  'doc',
  'docx',
  'docm',
  'dot',
  'dotx',
  'dotm',
  'odt',
  'fodt',
  'ott',
  'rtf',
  'txt',
  'html',
  'htm',
  'mht',
  'djvu',
  'fb2',
  'epub',
  'xps',
  'doc',
  'docx',
  'docm',
  'dot',
  'dotx',
  'dotm',
  'odt',
  'fodt',
  'ott',
  'rtf',
  'txt',
  'html',
  'htm',
  'mht',
  'djvu',
  'fb2',
  'epub',
  'xps',
  'xls',
  'xlsx',
  'xlsm',
  'xlt',
  'xltx',
  'xltm',
  'ods',
  'fods',
  'ots',
  'csv',
  'pps',
  'ppsx',
  'ppsm',
  'ppt',
  'pptx',
  'pptm',
  'pot',
  'potx',
  'potm',
  'odp',
  'fodp',
  'otp'
];

//冰蓝在线编辑的配置------end

// 图标icon转换
export function selectSvgIcon(item) {
  if (item.type == 'folder') {
    return 'file-close';
  } else {
    let result = '';
    for (let i = 0; i < iconArray.length; i++) {
      const iconArrayItem = iconArray[i];
      const suffixItem = iconArrayItem.suffix;
      const icon = iconArrayItem.icon;
      result = suffixItem.some(function (val) {
        return val == item.suffix;
      });
      if (result) {
        return icon;
      }
    }
    return 'weizhiwenjian';
  }
}

//字节单位大转换小
/**
 * val:值  例如 10
 * unit:单位 例如"GB"
 * 使用方法:unitBigToSmall(10,"GB")
 */
export function unitBigToSmall(val, unit) {
  if (!val) return '-';
  if (val == 0) return 0;
  let sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  let index = sizes.findIndex((item) => {
    return item == unit;
  });
  return parseInt(val) * Math.pow(1024, index);
}

// 字节单位获取单位
export function getByteUnit(val) {
  if (isNaN(val)) return '';
  var list = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  var temp = Math.floor(Math.log(val) / Math.log(2));
  if (temp < 1) temp = 0;
  var num = Math.floor(temp / 10);
  val = val / Math.pow(2, 10 * num);
  if (val.toString().length > val.toFixed(2).toString().length) val = val.toFixed(2);
  let dataObj = {
    size: val,
    unit: list[num]
  };
  return dataObj;
}

/*
div拖拽改变大小
参考地址：  https://blog.csdn.net/weixin_48398799/article/details/116535864
*/
export function dragControllerDiv() {
  var resize = document.getElementsByClassName('dragResize');
  var left = document.getElementsByClassName('dragLeft');
  var mid = document.getElementsByClassName('dragMid'); //右侧
  var box = document.getElementsByClassName('dragBox');
  // console.log(box[0].clientWidth);
  for (let i = 0; i < resize.length; i++) {
    // 鼠标按下事件
    resize[i].onmousedown = function (e) {
      //颜色改变提醒
      resize[i].style.background = '#818181';
      var startX = e.clientX;
      resize[i].left = resize[i].offsetLeft;
      // 鼠标拖动事件
      document.onmousemove = function (e) {
        var endX = e.clientX;
        var moveLen = resize[i].left + (endX - startX) - 265; // （endx-startx）=移动的距离。resize[i].left+移动的距离=左边区域最后的宽度
        var maxT = box[i].clientWidth - resize[i].offsetWidth; // 容器宽度 - 左边区域的宽度 = 右边区域的宽度
        // console.log(box[i].clientWidth);
        if (moveLen < 10) moveLen = 10; // 左边区域的最小宽度为10px
        if (moveLen > maxT - 40) moveLen = maxT - 40; //右边区域最小宽度为40px

        resize[i].style.left = moveLen; // 设置左侧区域的宽度

        for (let j = 0; j < left.length; j++) {
          left[j].style.width = moveLen + 'px';
          mid[j].style.width = box[i].clientWidth - moveLen - 10 + 'px';
          window.onresize = () => {
            //浏览器窗口变动的时候
            mid[j].style.width = document.body.clientWidth - moveLen - 215 + 'px';
          };
        }
      };

      // 鼠标松开事件
      document.onmouseup = function (evt) {
        //颜色恢复
        resize[i].style.background = '#d6d6d6';
        document.onmousemove = null;
        document.onmouseup = null;
        resize[i].releaseCapture && resize[i].releaseCapture(); //当你不在需要继续获得鼠标消息就要应该调用ReleaseCapture()释放掉
      };
      resize[i].setCapture && resize[i].setCapture(); //该函数在属于当前线程的指定窗口里设置鼠标捕获
      return false;
    };
  }
}

// 随机生成密码
export function randomPassword(size) {
  // var seed = new Array('A','B','C','D','E','F','G','H','I','J','K','L','M','N','P','Q','R','S','T','U','V','W','X','Y','Z',
  // 'a','b','c','d','e','f','g','h','i','j','k','m','n','p','Q','r','s','t','u','v','w','x','y','z',
  // '2','3','4','5','6','7','8','9'
  // );//数组
  var seed = new Array(
    'a',
    'b',
    'c',
    'd',
    'e',
    'f',
    'g',
    'h',
    'i',
    'j',
    'k',
    'm',
    'n',
    'p',
    'q',
    'r',
    's',
    't',
    'u',
    'v',
    'w',
    'x',
    'y',
    'z',
    '2',
    '3',
    '4',
    '5',
    '6',
    '7',
    '8',
    '9'
  ); //数组
  let seedlength = seed.length; //数组长度
  var createPassword = '';
  for (let i = 0; i < size; i++) {
    let j = Math.floor(Math.random() * seedlength);
    createPassword += seed[j];
  }
  return createPassword;
}

// 时间戳转为时间
export function timestampToTime(timestamp) {
  var date = new Date(timestamp * 1000); //时间戳为10位需*1000，时间戳为13位的话不需乘1000
  var Y = date.getFullYear() + '-';
  var M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';
  var D = date.getDate() + ' ';
  var h = date.getHours() + ':';
  var m = date.getMinutes() + ':';
  var s = date.getSeconds();
  return Y + M + D + h + m + s;
}
// 时间规则
export function getTimeRule(date) {
  var hour = parseInt((new Date() - new Date(date)) / 1000 / 60 / 60);
  if (hour >= 24) {
    return this.$moment(date).format('YYYY-MM-DD ');
  } else {
    return hour + '小时前';
  }
}

//---------------------------------------------------
// 拼接在线预览的字符
export function YUgetQueryParams(val) {
  let routerObj = {
    onlineId: val.id,
    onlineType: val.libraryType,
    suffix: val.suffix
  };

  return routerObj;
}

/** 在线预览和编辑的切换跳转 ------------start */
/**
 * 文件预览跳转页面
 * @param row 文件信息
 * @param isHistory 是否查看历史版本
 * @returns
 * params的ossId/versionId/moduleType这里不允许修改,如果自己不想改,就让后端改
 */
export function previewSkipPage(row, isHistory = false) {
  let path = '';
  let params = {
    moduleId: row.id, //文件id
    versionId: isHistory ? row.edition : '', //文件版本
    type: row.libraryType, //类型 不同模块库编码
    shareType: row.shareType, //分享类型
    shareId: row.shareId //分享id
  };

  if (suffixList.includes(row.suffix)) {
    path = '/onlinePreview-onlyOffice'; //跳转onlyOffice
  } else {
    path = '/onlinePreview-kkFileView'; //跳转kkFileView
  }
  const { href } = router.resolve({
    path: path,
    query: params
  });
  window.open(href, '_blank');
}

//编辑
export function onlineEditSkipPage(row, isHistory = false) {
  let path = '';
  let params = {
    moduleId: row.id, //文件id
    versionId: isHistory ? row.edition : '', //文件版本
    type: row.libraryType //类型 不同模块库编码
  };
  if (suffixList.includes(row.suffix)) {
    path = '/onlineEdit-onlyOffice';
  } else {
    alert('当前文件后缀类型不可编辑，请联系管理员在后台添加后缀');
    return false;
  }
  const { href } = router.resolve({
    path: path,
    query: params
  });
  window.open(href, '_blank');
}
//在线编辑
// export function onlineEditingFunc(row) {
//   let path = '';
//   onlineApi
//     .apiOnlineGetFilesDate({
//       id: row.id,
//       type: row.libraryType,
//       info: {
//         synergyId: row.synergyId ? row.synergyId : ''
//       }
//       // edition: row.edition
//     })
//     .then((res) => {
//       if (res.obj.edit) {
//         let routerObj = {
//           onlineId: res.obj.id,
//           onlineType: res.obj.libraryType
//         };
//         // if (isHistory == true) {
//         //   routerObj.edition = res.obj.edition
//         // }
//         if (res.obj.preview.toLocaleLowerCase() == 'iceblue') {
//           if (suffixList_iceBlue.includes(row.suffix)) {
//             path = '/onlineEditing-iceBlue';
//           } else {
//             alert('当前文件后缀类型不可编辑，请联系管理员在后台添加后缀');
//             return false;
//           }
//         } else if (res.obj.preview.toLocaleLowerCase() == 'onlyoffice') {
//           if (suffixList.includes(row.suffix)) {
//             path = '/onlineEditing-onlyOffice';
//           } else {
//             alert('当前文件后缀类型不可编辑，请联系管理员在后台添加后缀');
//             return false;
//           }
//         } else if (res.obj.preview.toLocaleLowerCase() == 'writefreely') {
//           //客户买了在线编辑
//           if (suffixList.includes(row.suffix)) {
//             path = '/onlineEditing';
//           } else {
//             alert('当前文件后缀类型不可编辑，请联系管理员在后台添加后缀');
//             return false;
//           }
//         }
//         const { href } = router.resolve({
//           path: path,
//           query: routerObj
//         });
//         window.open(href, '_blank');
//       } else {
//         alert('当前预览器不可编辑，请联系管理员进行修改预览器');
//       }
//     });
// }
/** 在线预览和编辑的切换跳转 ------------end */

//转换字符串来区分filetype用于请求参数
export function ParamTransition(val) {
  if (val == 'personal') return 0;
  if (val == 'team') return 1;
  if (val == 'enterprise') return 2;
}

// 用于编码颜色返回
export function selectColor(val) {
  if (val == 1) return 'y_red';
  if (val == 2) return 'y_orange';
  if (val == 3) return 'y_cyan';
  if (val == 4) return 'y_green';
  if (val == 5) return 'y_olive';
}

/*
 * 判断两个数组是否有重复的值
 * 有就返回true,没有就是false
 * arr1为面包屑数组,arr2为你选中文件的数组
 */
export function repetitionValFunc(arr1, arr2) {
  // 获取面包屑导航数组id
  let crumbsIds = arr1.map((item) => {
    return item.id;
  });
  // 选中的文件id
  let parentIds = arr2.map((item) => {
    return item.id;
  });
  let arr3 = crumbsIds.concat(parentIds);
  let new_arr = Array.from(new Set(arr3));
  if (new_arr.length < arr3.length) {
    //在这里面做你想做的操作
    return true;
  } else {
    return false;
  }
}

// 图片转base64
export function imgUrlToBase64(img) {
  var str = img;
  var encoder = new TextEncoder('utf-8');
  var encoded = encoder.encode(str);
  var base64EncodedStr = Buffer.from(encoded).toString('base64');
  return base64EncodedStr;
  // console.log(base64EncodedStr); // "aHR0cCUzQS8vMTkyLjE2OC42LjE0OSUzQTkwMDAvcHVibGljLWJ1Y2tldC8yMDIyLzEyLzA5LzE2NzA1NTAyNjYzODYtOTAwMzU0Nz
}

// base64转图片
export function base64ToImgUrl(dataurl, filename = 'file') {
  const img = 'data:image/png;base64,' + dataurl;
  let arr = img.split(',');
  let mime = arr[0].match(/:(.*?);/)[1];
  let suffix = mime.split('/')[1];
  let bstr = atob(arr[1]);
  let n = bstr.length;
  let u8arr = new Uint8Array(n);
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n);
  }
  return new File([u8arr], `${filename}.${suffix}`, {
    type: mime
  });
}

// 字典对比
export function dictComparison(arr, val) {
  let row = arr.find((item) => {
    return item.value == val;
  });
  return row.label;
}

//3.去除富文本中的图片
function richTitle(value) {
  let str = '';
  str = value.replace(/<\/?(img)[^>]*>/gi, '');
  str = str.replace(/<[^>]+>/g, '');
  return str;
}

// 2.从富文本中获取图片，如果没有返回一张默认图片
function richImgOne(value) {
  var imgList = [];
  value.replace(/<img [^>]*src=['"]([^'"]+)[^>]*>/g, function (match, capture) {
    imgList.push(capture);
  });

  if (imgList.length <= 0) {
    return '';
  }
  return imgList[0];
}
function richImgList(value) {
  var imgList = [];
  value.replace(/<img [^>]*src=['"]([^'"]+)[^>]*>/g, function (match, capture) {
    imgList.push(capture);
  });

  if (imgList.length <= 0) {
    return '';
  }
  return imgList;
}

// 动态修改浏览器导航栏图标和文字
function changeIconTitle(iconUrl) {
  const changeFavicon = (link) => {
    let $favicon = document.querySelector('link[rel="icon"]');
    if ($favicon !== null) {
      $favicon.href = link;
    } else {
      $favicon = document.createElement('link');
      $favicon.rel = 'icon';
      $favicon.href = link;
      document.head.appendChild($favicon);
    }
  };
  // let iconUrl = ""; // 图片地址
  let URLlabel = iconUrl ? store.state.api.baseApi + iconUrl : '../../public/favicon.ico';
  changeFavicon(URLlabel); // 动态修改网站图标
  let title = ''; // 网站标题
  document.title = title; // 动态修改网站标题
}

// 头像转化
export function imgSrc(img) {
  let Avatar = require('@/assets/images/avatar.png');
  // let src = img ? store.state.api.baseApi + '/imageFile/image/' + imgUrlToBase64(img)  : Avatar
  let src = img ? store.state.api.imageBaseUrl + img : Avatar;
  return src;
}
// 动态修改pageLogo页面logo
export function changePageLogo(img) {
  let logo = require('@/assets/images/logo.png');
  // let src = img ? store.state.api.baseApi + '/imageFile/image/' + imgUrlToBase64(img)  : logo
  // let src = img ? window.location.origin + img : logo
  let src = img ? store.state.api.imageBaseUrl + img : logo;
  return src;
}
//图片拼接地址
export function changePageImgPath(img) {
  let imgurl = require('@/assets/images/img-error1.png');
  // let src = img ? store.state.api.baseApi + '/imageFile/image/' + imgUrlToBase64(img)  : logo

  // let src = img ? store.state.api.baseApi + img : imgurl
  let src = img ? store.state.api.imageBaseUrl + img : imgurl;
  return src;
}
/** 获取两个日期之间的间隔日期
 * @param { Date | number | string } startTime 开始时间 标准时间格式 时间戳格式 字符串格式(2008-08-08,2008-8-8,2008-08-8,2008-8-08)
 * @param { Date | number | string } endTime 结束时间 标准时间格式 时间戳格式 字符串格式(2008-08-08,2008-8-8,2008-08-8,2008-8-08)
 *  */
function getBetweenDate(startTime, endTime) {
  // 校验时间格式
  if (typeof startTime === 'string') {
    const reg = /^\d{4}-(0?[1-9]|1[0-2])-((0?[1-9])|((1|2)[0-9])|30|31)$/g;
    if (!reg.test(startTime)) throw `开始时间：${startTime}时间格式错误`;
  }
  if (typeof endTime === 'string') {
    const reg = /^\d{4}-(0?[1-9]|1[0-2])-((0?[1-9])|((1|2)[0-9])|30|31)$/g;
    if (!reg.test(endTime)) throw `结束时间：${endTime}时间格式错误`;
  }
  let start = new Date(startTime);
  let end = new Date(endTime);
  const resultTime = [];
  // 当 开始时间小于结束时间的时候进入循环
  while (start <= end) {
    let getDay = start.getDate();
    // 月份需要加 1
    let getMonth = start.getMonth() + 1;
    let getYear = start.getFullYear();
    /**
     * 拼接时间格式
     * (getMonth >= 10 ? `${getMonth}` : `0${getMonth}`) 自动给 小于10的时间前面补0
     */
    let setTime = `${getYear}-` + (getMonth >= 10 ? `${getMonth}` : `0${getMonth}`) + '-' + (getDay >= 10 ? `${getDay}` : `0${getDay}`);
    resultTime.push(setTime);
    /**
     * 重新设置开始时间
     * 使用 setFullYear() 方法会自动将时间累加，返回的是时间戳格式
     * 使用 new Date() 将时间重新设置为标准时间
     * getMonth - 1 将月份时间重新还原
     */
    start = new Date(start.setFullYear(getYear, getMonth - 1, getDay + 1));
  }
  return resultTime;
}

// v-if 权限的判断
export function vifpermissionRoles(value) {
  if (value && value instanceof Array && value.length > 0) {
    const roles = store.getters && store.getters.roles;
    const permissionRoles = value;
    return roles.some((role) => {
      return permissionRoles.includes(role);
    });
  } else {
    // console.error(`need roles! Like v-permission="['admin','editor']"`)
    return false;
  }
}

// 获取文件的文件名和后缀
function getFileNameAndExtension(filePath) {
  var startIndex = filePath.lastIndexOf('/') + 1;
  var endIndex = filePath.lastIndexOf('.');
  var fileName = filePath.substring(startIndex, endIndex);
  var extension = filePath.substring(endIndex + 1);
  return {
    fileName: fileName,
    extension: extension
  };
}

// 使用证书来配置显示模块
// function LicenseInfoFunc(value, arr) {
// 	if (value == undefined || value == "") {
// 		return true
// 	} else {
// 		if (arr != undefined) {
// 			if (!arr.includes(value)) return true
// 		}
// 		return store.state.app.LicenseInfo.includes(value)
// 	}

// }
/**
 * 使用证书来配置显示模块
 * @author yuLiang
 * @param { string } value 证书字符串
 * @param { array } arr  如果是菜单里的证书,就要传一个数组过来,如果不是菜单证书就不需要传
 * 例如:$yuUtils.LicenseInfoFunc('template',['template'])
 * @returns 布尔值,是否显示菜单
 */
function LicenseInfoFunc(value, arr) {
  if (!value) {
    return true;
  } else if (arr && !arr.includes(value)) {
    return true;
  } else {
    return store.state.app.LicenseInfo.includes(value);
  }
}

/**
 * 文档权限判断
 * @param {array} value 要判断的权限
 * @param {array} myRoleList 我拥有的权限
 *  */
function documentsPermissionFunc(value, myRoleList) {
  if (value && value instanceof Array && value.length > 0) {
    const roles = myRoleList;
    const permissionRoles = value;
    return roles.some((role) => {
      return permissionRoles.includes(role);
    });
  } else {
    // console.error(`need roles! Like v-permission="['admin','editor']"`)
    return false;
  }
}
/**
 * 防抖
 * @param {*} fn //一个需要进行防抖处理的原函数fn
 * @param {*} delay //延迟执行的时间delay（单位为毫秒）
 * @returns 
 * import { debounce, throttle } from "@/utils/yuUtils.js";
 *  debounce_sureDialogTransferClick: debounce(function (val) {
      this.sureDialogTransferClick(val);
    }, 800),
 */
export function debounce(fn, delay) {
  let timer = null;

  return function (...args) {
    if (timer) {
      clearTimeout(timer);
    }
    timer = setTimeout(() => {
      fn.apply(this, args);
      timer = null;
    }, delay);
  };
}
/**
 * 节流
 * @param {*} fn //一个需要进行防抖处理的原函数fn
 * @param {*} delay //延迟执行的时间delay（单位为毫秒）
 * @returns
 */
export function throttle(fn, delay) {
  let canRun = true;

  return function (...args) {
    if (!canRun) return;

    canRun = false;
    setTimeout(() => {
      fn.apply(this, args);
      canRun = true;
    }, delay);
  };
}

/**
 * 文件名字的正则表达式验证
 */
export function isValidFileName(str) {
  const regex = /^(?!~\$)[^\/\\\:\*\?"<>\|\\]{1,216}$/;
  return regex.test(str);
}

/**全局设置单独通知样式 */
export function setNotification(str) {
  const notificationContent = `
    <div style=" display: flex;align-items: center;margin-bottom: 10px;">
      <img src="${bugIcon}" style="width: 18px;margin-right: 10px;" />
        <div style="font-size: 16px;color: #303123;font-weight: bold;">提示</div>
    </div>
    <p>${str}</p>
  `;
  Notification({
    message: notificationContent,
    duration: 5000,
    dangerouslyUseHTMLString: true
  });
}
// 保留两位小数
export function formatToTwoDecimalsWithoutRounding(num) {
  num = num ? num : 0;
  // 转换为字符串，然后分割整数和小数部分
  let [integerPart, decimalPart] = num.toString().split('.');
  // 取小数部分的前两位，如果没有小数部分则默认为0
  decimalPart = (decimalPart ? decimalPart : '')?.slice(0, 2);
  // 如果小数部分不足两位，用0填充
  while (decimalPart.length < 2) {
    decimalPart += '0';
  }
  // 拼接整数和处理后的两位小数部分
  return `${integerPart}.${decimalPart}`;
}

// 文件大小转换
export function filterSizeUnit(val) {
  //  if(!val) return "-"
  // if(val===0) return "0 B"
  // let k = 1024
  // let sizes = ['B','KB','MB','GB','TB','PB','EB','ZB','YB']
  // let i = Math.floor(Math.log(val) /Math.log(k))
  // return (val / Math.pow(k,i)).toPrecision(3) + " " + sizes[i]
  if (isNaN(val)) return '-';
  if (val < 0) return '-';
  var list = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
  var temp = Math.floor(Math.log(val) / Math.log(2));
  if (temp < 1) temp = 0;
  var num = Math.floor(temp / 10);
  val = val / Math.pow(2, 10 * num);
  // if (val.toString().length > val.toFixed(2).toString().length) val = val.toFixed(2);
  if (val.toString().length > val.toFixed(2).toString().length) val = Math.floor(val * 100) / 100;
  return val + ' ' + list[num];
}

//下拉动画
export function animation(obj, target, fn1) {
  // console.log(fn1);
  // fn是一个回调函数，在定时器结束的时候添加
  // 每次开定时器之前先清除掉定时器
  clearInterval(obj.timer);
  obj.timer = setInterval(function () {
    // 步长计算公式  越来越小
    // 步长取整
    var step = (target - obj.scrollTop) / 10;
    step = step > 0 ? Math.ceil(step) : Math.floor(step);
    if (obj.scrollTop >= target - 2) {
      clearInterval(obj.timer);
      // 如果fn1存在，调用fn
      if (fn1) {
        fn1();
      }
    } else {
      // 每30毫秒就将新的值给obj.left
      obj.scrollTop = obj.scrollTop + step;
    }
  }, 10);
}

// 复制
export function YUcopyToClipboard(content) {
  const clipboardData = window.clipboardData;
  if (clipboardData) {
    clipboardData.clearData();
    clipboardData.setData('Text', content);
    return true;
  } else if (document.execCommand) {
    const el = document.createElement('textarea');
    el.value = content;
    el.setAttribute('readonly', '');
    el.style.position = 'absolute';
    el.style.left = '-9999px';
    document.body.appendChild(el);
    el.select();
    document.execCommand('copy');
    document.body.removeChild(el);
    return true;
  }
  return false;
}

export default {
  suffixLists,
  selectSvgIcon,
  unitBigToSmall,
  getByteUnit,
  dragControllerDiv,
  randomPassword,
  timestampToTime,
  YUgetQueryParams,
  ParamTransition,
  selectColor,
  repetitionValFunc,
  imgUrlToBase64,
  imgSrc,
  previewSkipPage,
  onlineEditSkipPage,
  dictComparison,
  richTitle,
  richImgOne,
  richImgList,
  changeIconTitle,
  changePageLogo,
  getBetweenDate,
  vifpermissionRoles,
  getFileNameAndExtension,
  LicenseInfoFunc,
  getTimeRule,
  documentsPermissionFunc,
  changePageImgPath,
  debounce,
  throttle,
  isValidFileName,
  setNotification,
  formatToTwoDecimalsWithoutRounding,
  filterSizeUnit,
  animation,
  YUcopyToClipboard
};
